import accuracy_function from '../accuracy_function.js';

export default {



	/**
	 * 获取当前页面栈
	 */
	prePage() {
		let pages = getCurrentPages();
		let prePage = pages[pages.length - 2];
		// #ifdef H5
		return prePage;
		// #endif
		return prePage.$vm;
	},

	/**
	 * 加法精度计算
	 * @param {Object} number 数字
	 */
	add(a, b) {
		return accuracy_function.bcadd(a, b);
	},

	/**
	 * 减法精度计算
	 * @param {Object} number 数字
	 */
	sub(a, b) {
		return accuracy_function.bcsub(a, b);
	},

	/**
	 * 乘法精度计算
	 * @param {Object} number 数字
	 */
	mul(a, b) {
		return accuracy_function.bcmul(a, b);
	},

	/**
	 * 除法精度计算
	 * @param {Object} number 数字
	 */
	div(a, b) {
		return accuracy_function.bcdiv(a, b);
	},
	/**
	 * 获取系统信息
	 */
	sys() {
		let sys = uni.getSystemInfoSync();
		let data = {
			top: sys.statusBarHeight,
			height: sys.statusBarHeight + uni.upx2px(90),
			screenHeight: sys.screenHeight,
			platform: sys.platform,
			model: sys.model,
			windowHeight: sys.windowHeight,
			windowBottom: sys.windowBottom
		};
		// #ifndef MP
		data.height = sys.statusBarHeight + uni.upx2px(90);
		// #endif
		// #ifdef MP-WEIXIN || MP-BAIDU || MP-QQ || MP-TOUTIAO || MP-WEIXIN
		let custom = uni.getMenuButtonBoundingClientRect();
		data.height = custom.bottom + custom.top - sys.statusBarHeight;
		// #endif		
		// #ifdef MP-ALIPAY
		data.height = sys.statusBarHeight + sys.titleBarHeight;
		// #endif
		wanlshop_config.debug ? console.log(data) : '';
		return data;
	},

	/**
	 * 修改标题栏
	 * @param {Object} text 新标题
	 * @param {Object} barColor 导航栏颜色
	 */
	title(text = '', setbar = {}) {
		if (text) {
			uni.setNavigationBarTitle({
				title: text
			});
		}
		if (JSON.stringify(setbar) != "{}") {
			uni.setNavigationBarColor(setbar);
		}
	},
	/**
	 * 数字格式化
	 * @param {Object} number 数字
	 * @param {Object} type 类型 thousand:万,hundred:百
	 */
	numFormat(number, type) {
		//格式千位以上
		if (type == 'thousand') {
			if (number > 9999) {
				number = (number / 10000).toFixed(1) + 'w'
			} else if (number > 999) {
				number = (number / 1000).toFixed(1) + 'k'
			}
		}
		//格式百位
		if (type == 'hundred' && number > 99) {
			number = '99+';
		}
		return number;
	},


	/**
	 * 时间格式化
	 * @param String timestamp 时间戳
	 * @param String fmt 返回的时间格式
	 * yyyy:mm:dd|yyyy:mm|yyyy年mm月dd日|yyyy年mm月dd日 hh时MM分等,可自定义组合
	 */
	timeFormat(timestamp = null, fmt = 'yyyy-mm-dd') {
		// 其他更多是格式化有如下:
		// yyyy:mm:dd|yyyy:mm|yyyy年mm月dd日|yyyy年mm月dd日 hh时MM分等,可自定义组合
		timestamp = parseInt(timestamp);
		// 如果为null,则格式化当前时间
		if (!timestamp) timestamp = Number(new Date());
		// 判断用户输入的时间戳是秒还是毫秒,一般前端js获取的时间戳是毫秒(13位),后端传过来的为秒(10位)
		if (timestamp.toString().length == 10) timestamp *= 1000;
		let date = new Date(timestamp);
		let ret;
		let opt = {
			"y+": date.getFullYear().toString(), // 年
			"m+": (date.getMonth() + 1).toString(), // 月
			"d+": date.getDate().toString(), // 日
			"h+": date.getHours().toString(), // 时
			"M+": date.getMinutes().toString(), // 分
			"s+": date.getSeconds().toString() // 秒
			// 有其他格式化字符需求可以继续添加，必须转化成字符串
		};
		for (let k in opt) {
			ret = new RegExp("(" + k + ")").exec(fmt);
			if (ret) {
				fmt = fmt.replace(ret[1], (ret[1].length == 1) ? (opt[k]) : (opt[k].padStart(ret[1].length, "0")))
			};
		};
		return fmt;
	},

	/**
	 * 社交时间友好
	 * @param String timestamp 时间戳
	 * @param String | Boolean format 如果为时间格式字符串，超出一定时间范围，返回固定的时间格式；
	 * 如果为布尔值false，无论什么时间，都返回多久以前的格式
	 */
	timeToDate(timestamp = null, format = 'yyyy-mm-dd') {
		if (timestamp == null) timestamp = Number(new Date());
		timestamp = parseInt(timestamp);
		// 判断用户输入的时间戳是秒还是毫秒,一般前端js获取的时间戳是毫秒(13位),后端传过来的为秒(10位)
		if (timestamp.toString().length == 10) timestamp *= 1000;
		var timer = (new Date()).getTime() - timestamp;
		timer = parseInt(timer / 1000);
		// 如果小于5分钟,则返回"刚刚",其他以此类推
		let tips = '';
		switch (true) {
			case timer < 300:
				tips = '刚刚';
				break;
			case timer >= 300 && timer < 3600:
				tips = parseInt(timer / 60) + '分钟前';
				break;
			case timer >= 3600 && timer < 86400:
				tips = parseInt(timer / 3600) + '小时前';
				break;
			case timer >= 86400 && timer < 2592000:
				tips = parseInt(timer / 86400) + '天前';
				break;
			default:
				// 如果format为false，则无论什么时间戳，都显示xx之前
				if (format === false) {
					if (timer >= 2592000 && timer < 365 * 86400) {
						tips = parseInt(timer / (86400 * 30)) + '个月前';
					} else {
						tips = parseInt(timer / (86400 * 365)) + '年前';
					}
				} else {
					tips = timeFormat(timestamp, format);
				}
		}
		return tips;
	},

	/**
	 * IM时间友好
	 * @param String timestamp 时间戳
	 * @param String | Boolean format 如果为时间格式字符串，超出一定时间范围，返回固定的时间格式；
	 * 如果为布尔值false，无论什么时间，都返回多久以前的格式
	 */
	timeToChat(timestamp = null) {
		if (timestamp == null) timestamp = Number(new Date());
		timestamp = parseInt(timestamp);
		// 判断用户输入的时间戳是秒还是毫秒,一般前端js获取的时间戳是毫秒(13位),后端传过来的为秒(10位)
		if (timestamp.toString().length == 10) timestamp *= 1000;
		var timer = (new Date()).getTime() - timestamp;
		timer = parseInt(timer / 1000);
		// 如果小于5分钟,则返回"刚刚",其他以此类推
		let tips = '';
		switch (true) {
			case timer < 86400:
				tips = timeFormat(timestamp, 'hh:MM');
				break;
			case timer >= 86400 && timer < 86400 * 7:
				var now = new Date(timestamp);
				var week = ['日', '一', '二', '三', '四', '五', '六'];
				switch (new Date().getDate() - now.getDate()) {
					case 1:
						tips = timeFormat(timestamp, '昨天 hh:MM');
						break;
					case 2:
						tips = timeFormat(timestamp, '前天 hh:MM');
						break;
					default:
						tips = '星期' + week[now.getDay()] + timeFormat(timestamp, 'hh:MM');
				}
				break;
			case timer >= 86400 * 7:
				tips = timeFormat(timestamp, 'mm-dd hh:MM');
				break;
			default:
				tips = timeFormat(timestamp, 'yyyy-mm-dd hh:MM');
		}
		return tips;
	},

	/**
	 * @param {Number} len uuid的长度
	 * @param {Boolean} firstU 将返回的首字母置为"u"
	 * @param {Nubmer} radix 生成uuid的基数(意味着返回的字符串都是这个基数),2-二进制,8-八进制,10-十进制,16-十六进制
	 */
	guid(len = 32, firstU = true, radix = null) {
		let chars = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'.split('');
		let uuid = [];
		radix = radix || chars.length;

		if (len) {
			// 如果指定uuid长度,只是取随机的字符,0|x为位运算,能去掉x的小数位,返回整数位
			for (let i = 0; i < len; i++) uuid[i] = chars[0 | Math.random() * radix];
		} else {
			let r;
			// rfc4122标准要求返回的uuid中,某些位为固定的字符
			uuid[8] = uuid[13] = uuid[18] = uuid[23] = '-';
			uuid[14] = '4';

			for (let i = 0; i < 36; i++) {
				if (!uuid[i]) {
					r = 0 | Math.random() * 16;
					uuid[i] = chars[(i == 19) ? (r & 0x3) | 0x8 : r];
				}
			}
		}
		// 移除第一个字符,并用u替代,因为第一个字符为数值时,该guuid不能用作id或者class
		if (firstU) {
			uuid.shift();
			return 'u' + uuid.join('');
		} else {
			return uuid.join('');
		}
	},
	/**
	 * 页面跳转
	 * @param {Object} url 需要跳转的应用内非 tabBar 的页面的路径
	 * @param {Object} animationType 窗口显示的动画效果
	 * @param {Object} animationDuration 窗口动画持续时间，单位为 ms
	 */
	to(url, animationType = 'pop-in', animationDuration = 300) {
		uni.navigateTo({
			url,
			animationType,
			animationDuration,
			success: function(res) {
				//wanlshop_config.debug ? console.log(res) : '';
			},
			fail: function(e) {
				//wanlshop_config.debug ? console.log(e) : '';
			}
		})
	},

	/**
	 * 页面返回
	 * @param {Object} num 返回页面数量
	 */
	back(num = 1) {
		uni.navigateBack({
			delta: num
		});
	},
	/**
	 * 打开任意链接
	 * @param {Object} url 页面地址
	 */
	on(url) {
		url = decodeURIComponent(url);
		// 关闭所有页面，跳转链接
		if (url) {
			uni.switchTab({
				url: url
			});
		} else {
			to(url);
		}
	},
	/**
	 * 拨打电话 
	 * @param {JSON} number 电话号码
	 */
	phone(number) {
		uni.makePhoneCall({
			phoneNumber: number //仅为示例
		});
	},
	/**
	 * 格式化kb
	 * @param {JSON} limit kb
	 */
	conver(limit) {
		return (limit / (1024 * 1024)).toFixed(1) + "MB";
	},








	/**
	 * 跳转再封装，不支持复杂传参。
	 */
	routerTo(path, params = {}, isLogin) {
		let objParams = params;
		// 是否跳转外部链接
		if (~path.indexOf("http")) {
			// #ifdef H5
			window.location = path;
			// #endif
			// #ifndef  H5
			router.push({
				path: "/pages/public/webview",
				query: {
					webviewPath: path,
				},
			});
			// #endif
			return false;
		}
		// 判断是否有参数
		if (path.indexOf("?") !== -1) {
			let index = path.lastIndexOf("?");
			let query = path.substring(index + 1, path.length);
			let arr = query.split("&");
			path = path.slice(0, index);
			arr.forEach((item) => {
				let mArr = [];
				let obj = {};
				mArr = item.split("=");
				obj[mArr[0]] = mArr[1];
				objParams = {
					...objParams,
					...obj,
				};
			});
		}
		// 判断是否是tabbar
		if (isLogin) {
			router.replaceAll({
				path: path,
				query: objParams,
			});
		} else {
			router.push({
				path: path,
				query: objParams,
			});
		}
	},
	/**
	 * fn：检测图片协议，主要用于检测海报图片协议。
	 * param(imgPath): 图片地址。
	 */

	checkImgHttp(imgPath) {
		let newPath = "";
		let pathArr = imgPath.split("://");
		// #ifdef H5
		let ishttps = "https:" == window.location.protocol ? true : false;
		ishttps ? (pathArr[0] = "https") : (pathArr[0] = "http");
		// #endif
		// #ifdef MP-WEIXIN
		pathArr[0] = "https";
		// #endif
		newPath = pathArr.join("://");
		return newPath;
	},
	// 打电话
	callPhone(phoneNumber = "") {
		let num = phoneNumber.toString();
		uni.makePhoneCall({
			phoneNumber: num,
			fail(err) {
				console.log("makePhoneCall出错", err);
			},
		});
	},
	// 图片处理-选择图片
	chooseImage(count = 1) {
		return new Promise((resolve, reject) => {
			uni.chooseImage({
				count: count, //默认9
				sizeType: ["original", "compressed"], //可以指定是原图还是压缩图，默认二者都有
				sourceType: ["album"], //从相册选择
				success: (res) => {
					resolve(res.tempFilePaths);
				},
			});
		}).catch((e) => {
			reject(e);
		});
	},
	// 图片处理-上传图片
	uploadImage(api, url) {
		let config_url = API_URL;
		uni.showLoading({
			title: "上传中",
		});
		return new Promise((resolve, reject) => {
			uni.uploadFile({
				url: config_url + api,
				filePath: url,
				name: "file",
				success: (res) => {
					res = JSON.parse(res.data);
					if (res.code === 1) {
						uni.hideLoading();
						uni.showToast({
							title: "上传成功",
							icon: "none",
						});
						resolve(res.data);
					} else {
						uni.hideLoading();
						uni.showModal({
							title: "上传失败",
							content: res.msg,
						});
					}
				},
			});
		}).catch((e) => {
			reject(e);
		});
	},
	// 图片处理-预览图片
	previewImage(urls = [], current = 0) {
		uni.previewImage({
			urls: urls,
			current: current,
			indicator: "default",
			loop: true,
			fail(err) {
				console.log("previewImage出错", urls, err);
			},
		});
	},
	// 图片处理-获取图片信息
	getImageInfo(src = "") {
		return new Promise((resolve, reject) => {
			uni.getImageInfo({
				src: src,
				success: (image) => {
					resolve(image);
				},
				fail(err) {
					console.log("getImageInfo出错", src, err);
				},
			});
		}).catch((e) => {
			reject(e);
		});
	},
	/**
	 * 格式化时间
	 */
	//时间格式化 天时分秒
	format(t) {
		let format = {
			d: "00",
			h: "00",
			m: "00",
			s: "00",
		};
		if (t > 0) {
			let d = Math.floor(t / 86400);
			let h = Math.floor((t / 3600) % 24);
			let m = Math.floor((t / 60) % 60);
			let s = Math.floor(t % 60);
			format.d = d < 10 ? "0" + d : d;
			format.h = h < 10 ? "0" + h : h;
			format.m = m < 10 ? "0" + m : m;
			format.s = s < 10 ? "0" + s : s;
		}
		return format;
	},
	//时间格式化(格式化最大为小时)
	formatToHours(t) {
		let format = {
			d: "00",
			h: "00",
			m: "00",
			s: "00",
		};
		if (t > 0) {
			let h = Math.floor(t / 3600);
			let m = Math.floor((t / 60) % 60);
			let s = Math.floor(t % 60);

			format.h = h < 10 ? "0" + h : h;
			format.m = m < 10 ? "0" + m : m;
			format.s = s < 10 ? "0" + s : s;
		}
		return format;
	},
	// 年月日
	timestamp(timestamp) {
		let date = new Date(timestamp * 1000); //根据时间戳生成的时间对象
		let y = date.getFullYear();
		let m = date.getMonth() + 1;
		let d = date.getDate();

		m = m < 10 ? "0" + m : m;
		d = d < 10 ? "0" + d : d;

		let dateText = y + "-" + m + "-" + d;
		return dateText;
	},
	// 年月日，时分秒
	// "YYYY-mm-dd HH:MM"
	dateFormat(fmt, date) {
		let ret;
		const opt = {
			"Y+": date.getFullYear().toString(), // 年
			"m+": (date.getMonth() + 1).toString(), // 月
			"d+": date.getDate().toString(), // 日
			"H+": date.getHours().toString(), // 时
			"M+": date.getMinutes().toString(), // 分
			"S+": date.getSeconds().toString(), // 秒
			// 有其他格式化字符需求可以继续添加，必须转化成字符串
		};
		for (let k in opt) {
			ret = new RegExp("(" + k + ")").exec(fmt);
			if (ret) {
				fmt = fmt.replace(
					ret[1],
					ret[1].length == 1 ? opt[k] : opt[k].padStart(ret[1].length, "0")
				);
			}
		}
		return fmt;
	},
	/**
	 *  @fn  时间间隔格式化
	 *  @param {*} startTime 开始时间的时间戳
	 *  @param {*} endTime 结束时间的时间戳
	 *  @return {string} str 返回时间字符串
	 */
	getTimeInterval(startTime, endTime) {
		let runTime = parseInt((endTime - startTime) / 1000);
		let year = Math.floor(runTime / 86400 / 365);
		runTime = runTime % (86400 * 365);
		let month = Math.floor(runTime / 86400 / 30);
		runTime = runTime % (86400 * 30);
		let day = Math.floor(runTime / 86400);
		runTime = runTime % 86400;
		let hour = Math.floor(runTime / 3600);
		runTime = runTime % 3600;
		let minute = Math.floor(runTime / 60);
		runTime = runTime % 60;
		let second = runTime;
		let str = "";
		if (year > 0) {
			str = year + "年";
		}
		if (year <= 0 && month > 0) {
			str = month + "月";
		}
		if (year <= 0 && month <= 0 && day > 0) {
			str = day + "天";
		}
		if (year <= 0 && month <= 0 && day <= 0 && hour > 0) {
			str = hour + "小时";
		}
		if (year <= 0 && month <= 0 && day <= 0 && hour <= 0 && minute > 0) {
			str = minute + "分钟";
		}
		if (
			year <= 0 &&
			month <= 0 &&
			day <= 0 &&
			hour <= 0 &&
			minute <= 0 &&
			second > 0
		) {
			str += second + "秒";
		}
		str += "前";
		return str;
	},

	/**提示框
	 *title(标题)
	 *icon(图标):  success，loading，none
	 *duration(延时): 0为不关闭, 毫秒数
	 *options(其它参数)
	 */
	toast(title, icon = "none", options) {
		wx.showToast({
			title: title || "",
			icon: icon,
			duration: (options && options.duration) || 1500,
			image: (options && options.image) || "",
			mask: (options && options.mask) || true,
		});
	},

	/**
	 *@alias 节流
	 *@param {function} fn 节流被执行函数
	 *@param {Number}  delay 时间单位内
	 */
	throttle(fn, delay) {
		let flag = true,
			timer = null;
		return function(...args) {
			let context = this;
			if (!flag) return;
			flag = false;
			clearTimeout(timer);
			timer = setTimeout(() => {
				fn.apply(context, args);
				flag = true;
			}, delay);
		};
	},

	/**
	 *@alias 防抖
	 *@param {function} fn 防抖被执行函数
	 *@param {Number}  delay 时间单位内
	 */
	debounce(fn, delay) {
		let timer = null;
		return function(...args) {
			let context = this;
			if (timer) clearTimeout(timer);
			timer = setTimeout(function() {
				fn.apply(context, args);
			}, delay);
		};
	},
};
